Que fait «use strict» en JavaScript et quel est le raisonnement derrière cela?

Cet article sur Javascript Strict Mode pourrait vous intéresser: John Resig - ECMAScript 5 Strict Mode, JSON, etc.
Pour citer quelques parties intéressantes:
Le Mode Strict est une nouvelle fonctionnalité d'ECMAScript 5 qui permet de placer un programme, ou une fonction, dans un contexte d'exploitation "strict". Ce contexte strict empêche certaines actions d'être prises et génère plus d'exceptions.
Et:
Le mode strict est utile de plusieurs manières:
Il attrape quelques bloopers de codage courants, jetant des exceptions.
Il empêche, ou génère des erreurs, lorsque des actions relativement "dangereuses" sont entreprises (comme l'accès à l'objet global).
Il désactive les fonctionnalités déroutantes ou mal pensées.
Notez également que vous pouvez appliquer le "mode strict" à l'ensemble du fichier ... Ou vous pouvez l'utiliser uniquement pour une fonction spécifique (toujours en citant l'article de John Resig):
// Code non strict ...
(fonction(){
"utiliser strict";
// Définissez strictement votre bibliothèque ...
}) ();
// Code non strict ...
Ce qui peut être utile si vous devez mélanger l'ancien et le nouveau code ;-)
Donc, je suppose que c'est un peu comme le "use strict" que vous pouvez utiliser en Perl (d'où le nom?): Cela vous aide à faire moins d'erreurs, en détectant plus de choses qui pourraient conduire à des ruptures.
Le mode strict est désormais pris en charge par tous les principaux navigateurs.
À l'intérieur des modules ECMAScript natifs (avec des instructions d'importation et d'exportation) et des classes ES6, le mode strict est toujours activé et ne peut pas être désactivé.
|
C'est une nouvelle fonctionnalité d'ECMAScript 5. John Resig en a rédigé un joli résumé.
C'est juste une chaîne que vous mettez dans vos fichiers JavaScript (soit en haut de votre fichier ou à l'intérieur d'une fonction) qui ressemble à ceci:
"utiliser strict";
Le mettre dans votre code maintenant ne devrait pas poser de problèmes avec les navigateurs actuels car il ne s'agit que d'une chaîne. Cela peut causer des problèmes avec votre code à l'avenir si votre code enfreint le pragma. Par exemple, si vous avez actuellement foo = "bar" sans définir d'abord foo, votre code commencera à échouer ... ce qui est une bonne chose à mon avis.
|
La déclaration "use strict"; indique au navigateur d'utiliser le mode Strict, qui est un ensemble de fonctionnalités JavaScript réduit et plus sûr.
Liste des fonctionnalités (non exhaustive)
Interdit les variables globales. (Attrape les déclarations var manquantes et les fautes de frappe dans les noms de variables)
Les affectations silencieuses qui échouent généreront une erreur en mode strict (attribution de NaN = 5;)
Les tentatives de suppression des propriétés non supprimables entraîneront (supprimer Object.prototype)
Nécessite que tous les noms de propriété d'un littéral d'objet soient uniques (var x = {x1: "1", x1: "2"})
Les noms des paramètres de fonction doivent être uniques (function sum (x, x) {...})
Interdit la syntaxe octale (var x = 023; certains développeurs supposent à tort qu'un zéro précédent ne change rien au nombre.)
Interdit le mot clé avec
eval en mode strict n'introduit pas de nouvelles variables
Interdit la suppression des noms simples (supprimer x;)
Interdit la liaison ou l'attribution des noms eval et arguments sous quelque forme que ce soit
Le mode strict n'alias pas les propriétés de l'objet arguments avec les paramètres formels. (c'est-à-dire dans la fonction sum (a, b) {return arguments [0] + b;} Cela fonctionne car les arguments [0] sont liés à a et ainsi de suite.)
arguments.callee n'est pas pris en charge
[Réf: mode strict, Mozilla Developer Network]
|
Si les gens craignent d'utiliser use strict, il vaut peut-être la peine de consulter cet article:
Prise en charge d'ECMAScript 5 «Mode strict» dans les navigateurs. Qu'est-ce que cela signifie? NovoGeek.com - Le blog de Krishna
Il parle de la prise en charge du navigateur, mais surtout de la façon de le gérer en toute sécurité:
function isStrictMode () {
retour! ceci;
}
/ *
renvoie false, car 'this' fait référence à un objet global et
'! cela' devient faux
* /
function isStrictMode () {
"utiliser strict";
retour! ceci;
}
/ *
renvoie true, car en mode strict, le mot-clé 'this'
ne fait pas référence à un objet global, contrairement au JS traditionnel.
Donc ici, «ceci» est «indéfini» et «! Ceci» devient vrai.
* /
|
Un mot d'avertissement, vous tous les programmeurs qui ne demandent qu'à être durs: appliquer "use strict" au code existant peut être dangereux! Cette chose n'est pas un autocollant de bien-être et de visage heureux que vous pouvez appliquer sur le code pour le rendre «meilleur». Avec le pragma "use strict", le navigateur lancera soudainement des exceptions dans des endroits aléatoires qu'il n'avait jamais lancés auparavant simplement parce qu'à cet endroit vous faites quelque chose que JavaScript par défaut / lâche autorise heureusement mais le JavaScript abhorre! Vous pouvez avoir des violations de rigueur cachées dans les appels rarement utilisés dans votre code qui ne lèveront une exception que lorsqu'ils seront finalement exécutés - par exemple, dans l'environnement de production que vos clients payants utilisent!
Si vous allez franchir le pas, c'est une bonne idée d'appliquer "use strict" aux côtés de tests unitaires complets et d'une tâche de construction JSHint strictement configurée qui vous donnera une certaine confiance qu'il n'y a pas de coin sombre de votre module qui va exploser horriblement juste parce que vous avez activé le mode strict. Ou, hé, voici une autre option: n'ajoutez simplement "use strict" à aucun de vos anciens codes, c'est probablement plus sûr de cette façon, honnêtement. DEFINITIVEMENT NE PAS ajouter "use strict" aux modules que vous ne possédez pas oumaintenir, comme les modules tiers.
Je pense que même s'il s'agit d'un animal mortel en cage, «utiliser strict» peut être une bonne chose, mais vous devez le faire correctement. Le meilleur moment pour être strict est lorsque votre projet est entièrement vierge et que vous partez de zéro. Configurez JSHint / JSLint avec tous les avertissements et options aussi serrés que votre équipe peut le supporter, obtenez un bon système de construction / test / affirmation du jour truqué comme Grunt + Karma + Chai, et alors seulement commencez à marquer tous vos nouveaux modules comme " utiliser strict ". Soyez prêt à remédier à de nombreuses erreurs et avertissements insignifiants. Assurez-vous que tout le monde comprend la gravité en configurant la construction sur FAIL si JSHint / JSLint produit des violations.
Mon projet n'était pas un projet greenfield lorsque j'ai adopté "use strict". En conséquence, mon IDE est plein de marques rouges parce que je n'ai pas "use strict" sur la moitié de mes modules, et JSHint s'en plaint. Cela me rappelle ce que je devrais faire de refactoring à l'avenir. Mon objectif est d'être sans marque rouge en raison de toutes mes déclarations "use strict" manquantes, mais c'est dans des années maintenant.
|
Utilisation de 'use strict'; n'améliore pas soudainement votre code.
Le mode strict JavaScript est une fonctionnalité d'ECMAScript 5. Vous pouvez activer le mode strict en le déclarant en haut de votre script / fonction.
'use strict';
Lorsqu'un moteur JavaScript voit cette directive, il commence à interpréter le code dans un mode spécial. Dans ce mode, des erreurs sont générées lorsque certaines pratiques de codage qui pourraient finir par être des bogues potentiels sont détectées (ce qui est le raisonnement derrière le mode strict).
Prenons cet exemple:
var a = 365;
var b = 030;
Dans son obsession d'aligner les littéraux numériques, le développeur a initialisé par inadvertance la variable b avec un littéral octal. Le mode non strict interprétera cela comme un littéral numérique avec la valeur 24 (en base 10). Cependant, le mode strict générera une erreur.
Pour une liste non exhaustive des spécialités en mode strict, voir cette réponse.
Où devrais-je utiliser 'use strict' ;?
Dans ma nouvelle application JavaScript: Absolument! Le mode strict peut être utilisé comme dénonciateur lorsque vous faites quelque chose de stupide avec votre code.
Dans mon code JavaScript existant: Probablement pas! Si votre code JavaScript existant contient des instructions interdites en mode strict, l'application s'arrêtera simplement. Si vous souhaitez un mode strict, vous devez être prêt à déboguer et à corriger votre code existant. C'est pourquoi utiliser 'use strict'; n'améliore pas soudainement votre code.
Comment utiliser le mode strict?
Insérez un 'use strict'; déclaration en plus de votre script:
// Fichier: myscript.js
'use strict';
var a = 2;
....
Notez que tout ce qui se trouve dans le fichier myscript.js sera interprété en mode strict.
Ou, insérez un 'use strict'; déclaration au-dessus de votre corps de fonction:
function doSomething () {
'use strict';
...
}
Tout dans la portée lexicale de la fonction doSomething sera interprété en mode strict. Le mot portée lexicale est ici important. Par exemple, si votre code strict appelle une fonction d'une bibliothèque qui n'est pas stricte, seul votre code est exécuté en mode strict, et non la fonction appelée. Voir cette réponse pour une meilleure explication.
Quelles choses sont interdites en mode strict?
J'ai trouvé un bel article décrivant plusieurs choses qui sont interdites en mode strict (notez que ce n'est pas une liste exclusive):
Portée
Historiquement, JavaScript a été confus sur la façon dont fonctionne
sont étendues. Parfois, ils semblent avoir une portée statique, mais certains
les fonctionnalités les font se comporter comme si elles avaient une portée dynamique. C'est
déroutant, rendant les programmes difficiles à lire et à comprendre.
Un malentendu provoque des bugs. C'est aussi un problème de performance.
La portée statique permettrait la liaison de variable à la compilation
time, mais l'exigence de portée dynamique signifie que la liaison doit être
reporté à l'exécution, qui s'accompagne d'une performance significative
peine.
Le mode strict nécessite que toutes les liaisons de variables soient effectuées de manière statique.
Cela signifie que les fonctionnalités qui nécessitaient auparavant une liaison dynamique
doit être éliminé ou modifié. Plus précisément, l'instruction with est
éliminée, et la capacité de la fonction eval à altérer le
l'environnement de son appelant est sévèrement restreint.
L'un des avantages d'un code strict est que des outils comme YUI Compressor
peut faire un meilleur travail lors du traitement.
Variables globales implicites
JavaScript a impliqué des variables globales. Si
vous ne déclarez pas explicitement une variable, une variable globale est
déclaré implicitement pour vous. Cela facilite la programmation pour
débutants car ils peuvent négliger une partie de leur entretien ménager de base
corvées. Mais cela rend la gestion de programmes plus importants beaucoup plus
difficile et cela dégrade considérablement la fiabilité. Donc en stricte
mode, les variables globales implicites ne sont plus créées. Vous devriez
déclarez explicitement toutes vos variables.
Fuite mondiale
Il existe un certain nombre de situations qui pourraient causer ce
être lié à l'objet global. Par exemple, si vous oubliez de
fournir le nouveau préfixe lors de l'appel d'un constructeurfonction, le
ce constructeur sera lié de manière inattendue à l'objet global, donc
au lieu d'initialiser un nouvel objet, il sera à la place silencieusement
altération des variables globales. Dans ces situations, le mode strict
au lieu de cela, liez ceci à undefined, ce qui amènera le constructeur à
lancer une exception à la place, permettant à l'erreur d'être beaucoup détectée
plus tôt.
Panne bruyante
JavaScript a toujours eu des propriétés en lecture seule, mais vous
n'a pas pu les créer vous-même jusqu'à ce que Object.createProperty d'ES5
fonction a révélé cette capacité. Si vous avez tenté d'attribuer une valeur
à une propriété en lecture seule, il échouerait silencieusement. La mission serait
ne change pas la valeur de la propriété, mais votre programme se déroulera comme
si c'était le cas. Il s'agit d'un risque d'intégrité qui peut amener les programmes à
entrer dans un état incohérent. En mode strict, tenter de modifier un
La propriété en lecture seule lèvera une exception.
Octal
La représentation octale (ou base 8) des nombres était extrêmement
utile lors de la programmation au niveau de la machine sur des machines dont le mot
les tailles étaient un multiple de 3. Vous aviez besoin d'octal pour travailler avec le CDC
6600 mainframe, qui avait une taille de mot de 60 bits. Si tu pouvais lire
octal, vous pouvez regarder un mot avec 20 chiffres. Deux chiffres représentés
le code opération, et un chiffre identifiait l'un des 8 registres. Pendant le
transition lente des codes machine vers les langages de haut niveau, c'était
pensé pour être utile pour fournir des formes octales dans les langages de programmation.
En C, une représentation extrêmement malheureuse de l'octalité était
sélectionné: zéro non significatif. Donc en C, 0100 signifie 64, pas 100, et 08 est un
erreur, pas 8. Plus malheureusement encore, cet anachronisme a été
copié dans presque tous les langages modernes, y compris JavaScript, où
il n'est utilisé que pour créer des erreurs. Cela n'a pas d'autre but. Donc dans
mode strict, les formes octales ne sont plus autorisées.
Etc
Le pseudo tableau d'arguments devient un peu plus
comme un tableau dans ES5. En mode strict, il perd son appelant et son appelant
Propriétés. Cela permet de passer vos arguments à des
code sans renoncer à beaucoup de contexte confidentiel. Également
La propriété arguments des fonctions est éliminée.
En mode strict, les clés dupliquées dans un littéral de fonction produiront un
erreur de syntaxe. Une fonction ne peut pas avoir deux paramètres portant le même nom.
Une fonction ne peut pas avoir de variable portant le même nom que l’une de ses
paramètres. Une fonction ne peut pas supprimer ses propres variables. Une tentative de
supprimer une propriété non configurable lève désormais une exception. Primitif
les valeurs ne sont pas implicitement encapsulées.
Mots réservés pour les futures versions de JavaScript
ECMAScript 5 ajoute une liste de mots réservés. Si vous les utilisez comme variables ou arguments, le mode strict générera une erreur. Les mots réservés sont:
implémente, interface, let, package, privé, protégé, public, statique et rendement
Lectures complémentaires
Mode strict - JavaScript | MDN
Prise en charge du navigateur pour le mode strict
Transition vers le mode strict
|
Je recommande vivement à chaque développeur de commencer à utiliser le mode strict maintenant. Il existe suffisamment de navigateurs pour que le mode strict nous aide légitimement à nous éviter des erreurs dont nous ignorions même l'existence dans votre code.
Apparemment, au stade initial, il y aura des erreurs que nous n'avons jamais rencontrées auparavant. Pour en tirer pleinement parti, nous devons effectuer des tests appropriés après le passage en mode strict pour nous assurer que nous avons tout capturé. Nous ne nous contentons pas de lancer use strict dans notre code et de supposer qu’il n’y a pas d’erreurs. Le désabonnement est donc qu'il est temps de commencer à utiliser cette fonctionnalité de langage incroyablement utile pour écrire un meilleur code.
Par exemple,
var personne = {
nom: 'xyz',
position: 'abc',
fullname: function () {"use strict"; renvoyer this.name; }
};
JSLint est un débogueur écrit par Douglas Crockford. Collez simplement votre script et il recherchera rapidement les problèmes et erreurs visibles dans votre code.
|
Je voudrais offrir une réponse un peu plus fondée complétant les autres réponses. J'espérais modifier la réponse la plus populaire, mais j'ai échoué. J'ai essayé de le rendre aussi complet et complet que possible.
Vous pouvez consulter la documentation MDN pour plus d'informations.
"use strict" une directive introduite dans ECMAScript 5.
Les directives sont similaires aux déclarations, mais différentes.
use strict ne contient pas de mots clés: la directive est une instruction d'expression simple, qui consiste en une chaîne littérale spéciale (entre guillemets simples ou doubles). Les moteurs JavaScript, qui n'implémentent pas ECMAScript 5, voient simplement une instruction d'expression sans effets secondaires. On s'attend à ce que les futures versions des normes ECMAScript introduisent l'utilisation comme un véritable mot clé; les citations deviendraient ainsi obsolètes.
use strict ne peut être utilisé qu'au début d'un script ou d'une fonction, c'est-à-dire qu'il doit précéder toute autre instruction (réelle). Il n'est pas nécessaire qu'il s'agisse de la première instruction d'un script de fonction: elle peut être précédée d'autres expressions d'instructions constituées de littéraux de chaîne (et de JavaScriptles implémentations peuvent les traiter comme des directives spécifiques à l'implémentation). Les instructions de chaîne littérale, qui suivent une première instruction réelle (dans un script ou une fonction) sont de simples instructions d'expression. Les interprètes ne doivent pas les interpréter comme des directives et ils n'ont aucun effet.
La directive use strict indique que le code suivant (dans un script ou une fonction) est du code strict.
Le code du niveau le plus élevé d'un script (code qui n'est pas dans une fonction) est considéré comme du code strict lorsque le script contient une directive use strict.
Le contenu d'une fonction est considéré comme du code strict lorsque la fonction elle-même est définie dans un code strict ou lorsque la fonction contient une directive use strict.
Le code qui est passé à une méthode eval () est considéré comme du code strict quand eval () a été appelé à partir d'un code strict ou contient la directive use strict elle-même.
Le mode strict d'ECMAScript 5 est un sous-ensemble restreint du langage JavaScript, qui élimine les déficits pertinents du langage et offre une vérification des erreurs plus stricte et une sécurité accrue. Voici la liste des différences entre le mode strict et le mode normal (dont les trois premiers sont particulièrement importants):
Vous ne pouvez pas utiliser l'instruction with en mode strict.
En mode strict, toutes les variables doivent être déclarées: si vous attribuez une valeur à un identifiant qui n'a pas été déclaré comme variable, fonction, paramètre de fonction, paramètre de clause catch ou propriété de l'objet global, vous obtiendrez une ReferenceError. En mode normal, l'identifiant est implicitement déclaré en tant que variable globale (en tant que propriété de l'objet global)
En mode strict, le mot-clé this a la valeur non définie dans les fonctions qui ont été appelées en tant que fonctions (et non en tant que méthodes). (En mode normal, cela pointe toujours vers l'objet global). Cette différence peut être utilisée pour tester si une implémentation prend en charge le mode strict:
var hasStrictMode = (function () {"use strict"; return this === undefined} ());
De même, lorsqu'une fonction est appelée avec call () ou apply en mode strict, alors c'est exactement la valeur du premier argument de l'appel () ou apply (). (En mode normal, nul et non défini sont remplacés par l'objet global et les valeurs, qui ne sont pas des objets, sont converties en objets.)
En mode strict, vous obtiendrez une TypeError, lorsque vous essayez d'affecter des propriétés en lecture seule ou de définir de nouvelles propriétés pour un objet non extensible. (En mode normal, les deux échouent simplement sans message d'erreur.)
En mode strict, lorsque vous passez du code à eval (), vous ne pouvez pas déclarer ou définir des variables ou des fonctions dans la portée de l'appelant (comme vous pouvez le faire en mode normal). Au lieu de cela, une nouvelle portée est créée pour eval () et les variables et les fonctions sont dans cette portée. Cette portée est détruite après la fin de l'exécution de eval ().
En mode strict, l'objet-arguments d'une fonction contient une copie statique des valeurs, qui sont passées à cette fonction. En mode normal, l'objet arguments a un comportement quelque peu "magique": les éléments du tableau et les paramètres de la fonction nommée référencent tous les deux la même valeur.
En mode strict, vous obtiendrez une SyntaxError lorsque l'opérateur de suppression est suivi d'un identifiant non qualifié (une variable, une fonction ou un paramètre de fonction). En mode normal, l'expression de suppression ne ferait rien et est évaluée à false.
En mode strict, vous obtiendrez une TypeError lorsque vous essayez de supprimer une propriété non configurable. (En mode normal, la tentative échoue simplement et l'expression de suppression est évaluée à false).
En mode strict, cela est considéré comme une erreur de syntaxe lorsque vous essayez de définir plusieurs propriétés avec le même nom pour un littéral d'objet. (En mode normal, il n'y a pas d'erreur.)
En mode strict, il est considéré comme une erreur syntaxique lorsqu'une déclaration de fonction a plusieurs paramètres avec le même nom. (En mode normal, il n'y a pas d'erreur.)
En mode strict, les littéraux octaux ne sont pas autorisés (ce sont des littéraux commençant par 0x. (En mode normal, certaines implémentations autorisent les littéraux octaux).
En mode strict, les identifiants eval et arguments sont traités comme des mots-clés. Vous ne pouvez pas modifier leur valeur, leur attribuer une valeur et vous ne pouvez pas les utiliser comme noms pour des variables, des fonctions, des paramètres de fonction ou des identificateurs d'un bloc catch.
En mode strict, il y a plus de restrictions sur les possibilités d'examiner la pile d'appels. arguments.caller et arguments.callee provoquent une TypeError dans une fonction en mode strict. De plus, certaines propriétés de l'appelant et des arguments des fonctions en mode strict provoquent une TypeError lorsque vous essayez de les lire.
|
Mes deux centimes:
L'un des objectifs du mode strict est de permettre un débogage plus rapide des problèmes. Il aide les développeurs en lançant une exception lorsque certaines mauvaises choses se produisent qui peuvent provoquer un comportement silencieux et étrange de votre page Web. Au moment où nous utilisons use strict, le code jettera des erreurs qui aideront le développeur à le corriger à l'avance.
Peu de choses importantes que j'ai apprises après avoir utilisé use strict:
Empêche la déclaration de variable globale:
var tree1Data= {nom: 'Bananier', âge: 100, nombre de feuilles: 100000};
arbre de fonction (typeOfTree) {
var age;
var leafCount;
age = typeOfTree.age;
leafCount = typeOfTree.leafCount;
nameoftree = typeOfTree.name;
};
var tree1 = nouvel arbre (tree1Data);
console.log (fenêtre);
Maintenant, ce code crée nameoftree dans une portée globale qui peut être accédée en utilisant window.nameoftree. Lorsque nous implémentons use strict, le code génère une erreur.
Uncaught ReferenceError: nameoftree n'est pas défini
Échantillon
Élimine avec déclaration:
avec des instructions ne peuvent pas être minifiées à l'aide d'outils comme uglify-js. Ils sont également obsolètes et supprimés des futures versions de JavaScript.
Échantillon
Empêche les doublons:
Lorsque nous avons une propriété en double, cela lève une exception
Uncaught SyntaxError: propriété de données dupliquée dans le littéral objet non
autorisé en mode strict
"utiliser strict";
var tree1Data = {
nom: 'Banana Tree',
âge: 100,
nombre de feuilles: 100000,
nom: 'Bananier'
};
Il y en a peu de plus mais j'ai besoin d'acquérir plus de connaissances à ce sujet.
|
Si vous utilisez un navigateur sorti au cours de la dernière année, il prend probablement en charge le mode JavaScript Strict. Seuls les navigateurs plus anciens avant qu'ECMAScript 5 ne devienne le standard actuel ne le prennent pas en charge.
Les guillemets autour de la commande garantissent que le code fonctionnera toujours dans les navigateurs plus anciens (bien que les choses qui génèrent une erreur de syntaxe en mode strict provoquent généralement un dysfonctionnement du script d'une manière difficile à détecter dans ces anciens navigateurs).
|
Lors de l'ajout de "use strict" ;, les cas suivants lèveront une SyntaxError avant l'exécution du script:
Ouvrir la voie aux futures versions d'ECMAScript, en utilisant l'un des mots clés nouvellement réservés (en prévision pour ECMAScript 6): implements, interface, let, package, private, protected, public, static et yield.
Déclarer la fonction dans les blocs
if (a : 3: 15)
à : 6: 5
Ici, le compilateur renvoie l'erreur de référence. En mode strict, le compilateur ne nous permet pas d'utiliser la variable sans la déclarer. Ainsi, les fuites de mémoire peuvent être évitées. De plus, nous pouvons écrire du code plus optimisé.
|
Le mode strict élimine les erreurs qui seraient ignorées en mode non strict, rendant ainsi javascript «plus sécurisé».
Est-il considéré parmi les meilleures pratiques?
Oui, il est considéré comme faisant partie des meilleures pratiques lorsque vous travaillez avec javascript pour inclure le mode strict. Cela se fait en ajoutant la ligne de code ci-dessous dans votre fichier JS.
'use strict';
dans votre code.
Qu'est-ce que cela signifie pour les agents utilisateurs?
Indiquer que le code doit être interprété en mode strict spécifie aux agents utilisateurs comme les navigateurs qu'ils doivent traiter le code littéralement comme écrit, et lancer une erreur si le code n'a pas de sens.
Par exemple: considérez dans votre fichier .js que vous avez le code suivant:
Scénario 1: [PAS DE MODE STRICT]
var city = "Chicago"
console.log (city) // Imprime le nom de la ville, c'est-à-dire Chicago
Scénario 2: [PAS DE MODE STRICT]
city ​​= "Chicago"
console.log (city) // Imprime le nom de la ville, c'est-à-dire Chicago
Alors pourquoi le nom de la variable est-il imprimé dans les deux cas?
Sans le mode strict activé, les agents utilisateurs subissent souvent une série de modifications du code problématique pour tenter de lui donner un sens. En surface, cela peut sembler une bonne chose, et en effet, travailler en dehors du mode strict permet aux gens de se mouiller les pieds avec du code JavaScript sans avoir tous les détails bien définis. Cependant, en tant que développeur, je ne veux pas laisser de bogue dans mon code, car je sais qu'il pourrait revenir et me mordre plus tard, et je veux aussi juste écrire du bon code. Et c'est là que le mode strict aide.
Scénario 3: [MODE STRICT]
'use strict';
city ​​= "Chicago"
console.log (city) // Erreur de référence: asignment est une variable city non déclarée.
Conseil supplémentaire: pour maintenir la qualité du code en utilisant le mode strict, vous n'avez pas besoin de l'écrire encore et encore, surtout si vous avez plusieurs fichiers .js. Vous pouvez appliquer cette règle globalement dans les règles eslint comme suit:
Nom de fichier: .eslintrc.js
module.exports = {
env: {
es6: vrai
},
règles : {
strict: ['erreur', 'global'],
},
};
Ok, alors qu'est-ce qui est empêché en mode strict?
Utiliser une variable sans la déclarer lèvera une erreur en mode strict. Cela évite de créer involontairement des variables globales dans toute votre application. L'exemple avec l'impression de Chicago couvre ceci en particulier.
Supprimer une variable, une fonction ou un argument est un non-non en mode strict.
"utiliser strict";
fonction x (p1, p2) {};
supprimer x; // Cela provoquera une erreur
La duplication d'un nom de paramètre n'est pas autorisée en mode strict.
"utiliser strict";
fonction x (p1, p1) {}; // Cela provoquera une erreur
Les mots réservés en langage Javascript ne sont pas autorisés en mode strict. Les mots sont implémentations interface, let, packages, privé, protégé, public. statique et rendement
Pour une liste plus complète, consultez la documentation MDN ici: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
|
Question très active. Gagnez 10 points de réputation pour répondre à cette question. L'exigence de réputation permet de protéger cette question contre les spams et les activités sans réponse.
Ce n'est pas la réponse que vous recherchez? Parcourez les autres questions marquées syntaxe javascript jslint use-strict ou posez votre propre question.